{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Batch Normalization\n",
    "One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \n",
    "One idea along these lines is batch normalization which was proposed by [1] in 2015.\n",
    "\n",
    "The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n",
    "\n",
    "The authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [1] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n",
    "\n",
    "It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n",
    "\n",
    "[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
    "Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n",
    "\n",
    "def print_mean_std(x,axis=0):\n",
    "    print('  means: ', x.mean(axis=axis))\n",
    "    print('  stds:  ', x.std(axis=axis))\n",
    "    print() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:  (49000, 3, 32, 32)\n",
      "y_train:  (49000,)\n",
      "X_val:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.items():\n",
    "  print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: forward\n",
    "In the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n",
    "\n",
    "Referencing the paper linked to above in [1] may be helpful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before batch normalization:\n",
      "  means:  [ -2.3814598  -13.18038246   1.91780462]\n",
      "  stds:   [27.18502186 34.21455511 37.68611762]\n",
      "\n",
      "After batch normalization (gamma=1, beta=0)\n",
      "  means:  [7.10542736e-17 7.82707232e-17 9.71445147e-18]\n",
      "  stds:   [0.99999999 1.         1.        ]\n",
      "\n",
      "After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n",
      "  means:  [11. 12. 13.]\n",
      "  stds:   [0.99999999 1.99999999 2.99999999]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after batch normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before batch normalization:')\n",
    "print_mean_std(a,axis=0)\n",
    "\n",
    "gamma = np.ones((D3,))\n",
    "beta = np.zeros((D3,))\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After batch normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)\n",
    "\n",
    "gamma = np.asarray([1.0, 2.0, 3.0])\n",
    "beta = np.asarray([11.0, 12.0, 13.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After batch normalization (test-time):\n",
      "  means:  [-0.03927354 -0.04349152 -0.10452688]\n",
      "  stds:   [1.01531428 1.01238373 0.97819988]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the test-time forward pass by running the training-time\n",
    "# forward pass many times to warm up the running averages, and then\n",
    "# checking the means and variances of activations after a test-time\n",
    "# forward pass.\n",
    "\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "\n",
    "for t in range(50):\n",
    "  X = np.random.randn(N, D1) # 每次迭代这里的X也是不一样的\n",
    "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "  batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "bn_param['mode'] = 'test'\n",
    "X = np.random.randn(N, D1)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "# Means should be close to zero and stds close to one, but will be\n",
    "# noisier than training-time forward passes.\n",
    "print('After batch normalization (test-time):')\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: backward\n",
    "Now implement the backward pass for batch normalization in the function `batchnorm_backward`.\n",
    "\n",
    "To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n",
    "\n",
    "Once you have finished, run the following to numerically check your backward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.7029241291468676e-09\n",
      "dgamma error:  7.420414216247087e-13\n",
      "dbeta error:  2.8795057655839487e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
    "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
    "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
    "#You should expect to see relative errors between 1e-13 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: alternative backward\n",
    "In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n",
    "\n",
    "Surprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too!  \n",
    "\n",
    "In the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n",
    "\n",
    "we first calculate the mean $\\mu$ and variance $v$.\n",
    "With $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$  and normalized data $Y$.\n",
    "The equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n",
    "\n",
    "\\begin{align}\n",
    "& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k  &  v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n",
    "& \\sigma=\\sqrt{v+\\epsilon}         &  y_i=\\frac{x_i-\\mu}{\\sigma}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"notebook_images/batchnorm_graph.png\" width=691 height=202>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "The meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n",
    "\n",
    "The unknown/hart part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n",
    "$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n",
    "$\\frac{\\partial \\sigma}{\\partial v}$, \n",
    "$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\n",
    "and then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n",
    "\n",
    "If it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n",
    "\n",
    "You should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n",
    "\n",
    "After doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx difference:  9.20004371222927e-13\n",
      "dgamma difference:  0.0\n",
      "dbeta difference:  0.0\n",
      "speedup: 1.02x\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D = 100, 500\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "\n",
    "t1 = time.time()\n",
    "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
    "t2 = time.time()\n",
    "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
    "t3 = time.time()\n",
    "\n",
    "print('dx difference: ', rel_error(dx1, dx2))\n",
    "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
    "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
    "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fully Connected Nets with Batch Normalization\n",
    "Now that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n",
    "\n",
    "Concretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n",
    "\n",
    "HINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.2611955101340957\n",
      "W1 relative error: 1.10e-04\n",
      "W2 relative error: 2.85e-06\n",
      "W3 relative error: 4.05e-10\n",
      "b1 relative error: 4.44e-08\n",
      "b2 relative error: 4.44e-08\n",
      "b3 relative error: 1.01e-10\n",
      "beta1 relative error: 7.33e-09\n",
      "beta2 relative error: 1.89e-09\n",
      "gamma1 relative error: 6.96e-09\n",
      "gamma2 relative error: 1.96e-09\n",
      "\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  6.996533220108303\n",
      "W1 relative error: 1.98e-06\n",
      "W2 relative error: 2.29e-06\n",
      "W3 relative error: 2.79e-08\n",
      "b1 relative error: 2.78e-09\n",
      "b2 relative error: 4.44e-08\n",
      "b3 relative error: 2.10e-10\n",
      "beta1 relative error: 6.65e-09\n",
      "beta2 relative error: 4.23e-09\n",
      "gamma1 relative error: 6.27e-09\n",
      "gamma2 relative error: 5.28e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "# You should expect losses between 1e-4~1e-10 for W, \n",
    "# losses between 1e-08~1e-10 for b,\n",
    "# and losses between 1e-08~1e-09 for beta and gammas.\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64,\n",
    "                            normalization='batchnorm')\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
    "  if reg == 0: print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batchnorm for deep networks\n",
    "Run the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solver with batch norm:\n",
      "(Iteration 1 / 200) loss: 2.340975\n",
      "(Epoch 0 / 10) train acc: 0.107000; val_acc: 0.115000\n",
      "(Epoch 1 / 10) train acc: 0.314000; val_acc: 0.266000\n",
      "(Iteration 21 / 200) loss: 2.039365\n",
      "(Epoch 2 / 10) train acc: 0.385000; val_acc: 0.278000\n",
      "(Iteration 41 / 200) loss: 2.041103\n",
      "(Epoch 3 / 10) train acc: 0.491000; val_acc: 0.309000\n",
      "(Iteration 61 / 200) loss: 1.753903\n",
      "(Epoch 4 / 10) train acc: 0.528000; val_acc: 0.303000\n",
      "(Iteration 81 / 200) loss: 1.241217\n",
      "(Epoch 5 / 10) train acc: 0.592000; val_acc: 0.310000\n",
      "(Iteration 101 / 200) loss: 1.371031\n",
      "(Epoch 6 / 10) train acc: 0.645000; val_acc: 0.325000\n",
      "(Iteration 121 / 200) loss: 1.127300\n",
      "(Epoch 7 / 10) train acc: 0.688000; val_acc: 0.323000\n",
      "(Iteration 141 / 200) loss: 1.185820\n",
      "(Epoch 8 / 10) train acc: 0.740000; val_acc: 0.309000\n",
      "(Iteration 161 / 200) loss: 0.825490\n",
      "(Epoch 9 / 10) train acc: 0.777000; val_acc: 0.331000\n",
      "(Iteration 181 / 200) loss: 0.896460\n",
      "(Epoch 10 / 10) train acc: 0.787000; val_acc: 0.331000\n",
      "\n",
      "Solver without batch norm:\n",
      "(Iteration 1 / 200) loss: 2.302332\n",
      "(Epoch 0 / 10) train acc: 0.129000; val_acc: 0.131000\n",
      "(Epoch 1 / 10) train acc: 0.283000; val_acc: 0.250000\n",
      "(Iteration 21 / 200) loss: 2.041970\n",
      "(Epoch 2 / 10) train acc: 0.316000; val_acc: 0.277000\n",
      "(Iteration 41 / 200) loss: 1.900473\n",
      "(Epoch 3 / 10) train acc: 0.373000; val_acc: 0.282000\n",
      "(Iteration 61 / 200) loss: 1.713156\n",
      "(Epoch 4 / 10) train acc: 0.390000; val_acc: 0.310000\n",
      "(Iteration 81 / 200) loss: 1.662209\n",
      "(Epoch 5 / 10) train acc: 0.434000; val_acc: 0.300000\n",
      "(Iteration 101 / 200) loss: 1.696062\n",
      "(Epoch 6 / 10) train acc: 0.536000; val_acc: 0.346000\n",
      "(Iteration 121 / 200) loss: 1.550785\n",
      "(Epoch 7 / 10) train acc: 0.530000; val_acc: 0.310000\n",
      "(Iteration 141 / 200) loss: 1.436308\n",
      "(Epoch 8 / 10) train acc: 0.622000; val_acc: 0.342000\n",
      "(Iteration 161 / 200) loss: 1.000868\n",
      "(Epoch 9 / 10) train acc: 0.654000; val_acc: 0.328000\n",
      "(Iteration 181 / 200) loss: 0.925455\n",
      "(Epoch 10 / 10) train acc: 0.726000; val_acc: 0.335000\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [100, 100, 100, 100, 100]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2\n",
    "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "print('Solver with batch norm:')\n",
    "bn_solver = Solver(bn_model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True,print_every=20)\n",
    "bn_solver.train()\n",
    "\n",
    "print('\\nSolver without batch norm:')\n",
    "solver = Solver(model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=20)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n",
    "    \"\"\"utility function for plotting training history\"\"\"\n",
    "    plt.title(title)\n",
    "    plt.xlabel(label)\n",
    "    bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n",
    "    bl_plot = plot_fn(baseline)\n",
    "    num_bn = len(bn_plots)\n",
    "    for i in range(num_bn):\n",
    "        label='with_norm'\n",
    "        if labels is not None:\n",
    "            label += str(labels[i])\n",
    "        plt.plot(bn_plots[i], bn_marker, label=label)\n",
    "    label='baseline'\n",
    "    if labels is not None:\n",
    "        label += str(labels[0])\n",
    "    plt.plot(bl_plot, bl_marker, label=label)\n",
    "    plt.legend(loc='lower center', ncol=num_bn+1) \n",
    "\n",
    "    \n",
    "plt.subplot(3, 1, 1)\n",
    "plot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n",
    "                      lambda x: x.loss_history, bl_marker='o', bn_marker='o')\n",
    "plt.subplot(3, 1, 2)\n",
    "plot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "plt.subplot(3, 1, 3)\n",
    "plot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and initialization\n",
    "We will now run a small experiment to study the interaction of batch normalization and weight initialization.\n",
    "\n",
    "The first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running weight scale 1 / 20\n",
      "Running weight scale 2 / 20\n",
      "Running weight scale 3 / 20\n",
      "Running weight scale 4 / 20\n",
      "Running weight scale 5 / 20\n",
      "Running weight scale 6 / 20\n",
      "Running weight scale 7 / 20\n",
      "Running weight scale 8 / 20\n",
      "Running weight scale 9 / 20\n",
      "Running weight scale 10 / 20\n",
      "Running weight scale 11 / 20\n",
      "Running weight scale 12 / 20\n",
      "Running weight scale 13 / 20\n",
      "Running weight scale 14 / 20\n",
      "Running weight scale 15 / 20\n",
      "Running weight scale 16 / 20\n",
      "Running weight scale 17 / 20\n",
      "Running weight scale 18 / 20\n",
      "Running weight scale 19 / 20\n",
      "Running weight scale 20 / 20\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "bn_solvers_ws = {}\n",
    "solvers_ws = {}\n",
    "weight_scales = np.logspace(-4, 0, num=20)\n",
    "for i, weight_scale in enumerate(weight_scales):\n",
    "  print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
    "  bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "  model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "  bn_solver = Solver(bn_model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  bn_solver.train()\n",
    "  bn_solvers_ws[weight_scale] = bn_solver\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  solver.train()\n",
    "  solvers_ws[weight_scale] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results of weight scale experiment\n",
    "best_train_accs, bn_best_train_accs = [], []\n",
    "best_val_accs, bn_best_val_accs = [], []\n",
    "final_train_loss, bn_final_train_loss = [], []\n",
    "\n",
    "for ws in weight_scales:\n",
    "  best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n",
    "  bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n",
    "  \n",
    "  best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n",
    "  bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n",
    "  \n",
    "  final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n",
    "  bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n",
    "  \n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Best val accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best val accuracy')\n",
    "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
    "plt.legend(ncol=2, loc='lower right')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Best train accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best training accuracy')\n",
    "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Final training loss vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Final training loss')\n",
    "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "plt.gca().set_ylim(1.0, 3.5)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1:\n",
    "Describe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n",
    "总体上，weight_scale从0.0001到0.1的时候，无论是否进行了batch normalization都表现的越来越好（在训练集，验证集，总损失上），但超过了0.1的时候，就会变差；总体上有batch normalization表现好一点，对参数的初始化也不那么敏感"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and batch size\n",
    "We will now run a small experiment to study the interaction of batch normalization and batch size.\n",
    "\n",
    "The first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "pdf-ignore-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    }
   ],
   "source": [
    "def run_batchsize_experiments(normalization_mode):\n",
    "    np.random.seed(231)\n",
    "    # Try training a very deep net with batchnorm\n",
    "    hidden_dims = [100, 100, 100, 100, 100]\n",
    "    num_train = 1000\n",
    "    small_data = {\n",
    "      'X_train': data['X_train'][:num_train],\n",
    "      'y_train': data['y_train'][:num_train],\n",
    "      'X_val': data['X_val'],\n",
    "      'y_val': data['y_val'],\n",
    "    }\n",
    "    n_epochs=10\n",
    "    weight_scale = 2e-2\n",
    "    batch_sizes = [5,10,50]\n",
    "    lr = 10**(-3.5)\n",
    "    solver_bsize = batch_sizes[0]\n",
    "\n",
    "    print('No normalization: batch size = ',solver_bsize)\n",
    "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=n_epochs, batch_size=solver_bsize,\n",
    "                    update_rule='adam',\n",
    "                    optim_config={\n",
    "                      'learning_rate': lr,\n",
    "                    },\n",
    "                    verbose=False)\n",
    "    solver.train()\n",
    "    \n",
    "    bn_solvers = []\n",
    "    for i in range(len(batch_sizes)):\n",
    "        b_size=batch_sizes[i]\n",
    "        print('Normalization: batch size = ',b_size)\n",
    "        bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n",
    "        bn_solver = Solver(bn_model, small_data,\n",
    "                        num_epochs=n_epochs, batch_size=b_size,\n",
    "                        update_rule='adam',\n",
    "                        optim_config={\n",
    "                          'learning_rate': lr,\n",
    "                        },\n",
    "                        verbose=False)\n",
    "        bn_solver.train()\n",
    "        bn_solvers.append(bn_solver)\n",
    "        \n",
    "    return bn_solvers, solver, batch_sizes\n",
    "\n",
    "batch_sizes = [5,10,50]\n",
    "bn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2:\n",
    "Describe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n",
    "似乎batch normalization在batch size大的时候表现得好一点，batch size只有5的时候就比没有batch normalization的时候还差，这因为进行bn操作的时候，还是不能太小的batch size，因为太小以后，算出来的均值和方差不能代表一整个训练集的分布，所以不好，之后用的时候一定不能把这个查超参数设得太小"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization\n",
    "Batch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n",
    "\n",
    "Several alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n",
    "\n",
    "[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "Which of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n",
    "\n",
    "1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n",
    "2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1.  \n",
    "3. Subtracting the mean image of the dataset from each image in the dataset.\n",
    "4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization: Implementation\n",
    "\n",
    "Now you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n",
    "\n",
    "Here's what you need to do:\n",
    "\n",
    "* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_forward`. \n",
    "\n",
    "Run the cell below to check your results.\n",
    "* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the second cell below to check your results.\n",
    "* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n",
    "\n",
    "Run the third cell below to run the batch size experiment on layer normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before layer normalization:\n",
      "  means:  [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n",
      "  stds:   [10.07429373 28.39478981 35.28360729  4.01831507]\n",
      "\n",
      "After layer normalization (gamma=1, beta=0)\n",
      "  means:  [ 4.81096644e-16 -7.40148683e-17  2.22044605e-16 -5.92118946e-16]\n",
      "  stds:   [0.99999995 0.99999999 1.         0.99999969]\n",
      "\n",
      "After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n",
      "  means:  [5. 5. 5. 5.]\n",
      "  stds:   [2.99999985 2.99999998 2.99999999 2.99999907]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after layer normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 =4, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before layer normalization:')\n",
    "print_mean_std(a,axis=1)\n",
    "\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After layer normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)\n",
    "\n",
    "gamma = np.asarray([3.0,3.0,3.0])\n",
    "beta = np.asarray([5.0,5.0,5.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.433615657860454e-09\n",
      "dgamma error:  4.519489546032799e-12\n",
      "dbeta error:  2.276445013433725e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check layernorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "ln_param = {}\n",
    "fx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\n",
    "fg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\n",
    "fb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = layernorm_forward(x, gamma, beta, ln_param)\n",
    "dx, dgamma, dbeta = layernorm_backward(dout, cache)\n",
    "\n",
    "#You should expect to see relative errors between 1e-12 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization and batch size\n",
    "\n",
    "We will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 4:\n",
    "When is layer normalization likely to not work well, and why?\n",
    "\n",
    "1. Using it in a very deep network\n",
    "2. Having a very small dimension of features\n",
    "3. Having a high regularization term\n",
    "\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
